import { defineStore } from 'pinia'
import { ref, computed, watch } from 'vue'
import { useBindingStore } from './useBindingStore'
import { useHealthData } from './useHealthData'
import { get, post } from '@/utils/request.js'

export const usePatientStore = defineStore('patient', () => {
    const bindingStore = useBindingStore()
    const healthData = useHealthData()
    
    // 患者列表
    const patientList = ref([])
    
    // 当前选中的患者信息
    const curPatient = ref(null)
    
    // 当前患者的健康数据
    const curPatientHealthData = ref(null)
    
    // 当前患者的体检记录
    const curPatientRecords = ref([])
    
    // 加载状态
    const loading = ref({
        patientList: false,
        healthData: false,
        records: false
    })
    
    // 获取患者列表
    const getPatientList = computed(() => patientList.value || [])
    
    // 获取当前患者信息
    const getCurPatient = computed(() => curPatient.value)
    
    // 获取当前患者健康数据
    const getCurPatientHealthData = computed(() => curPatientHealthData.value)
    
    // 获取当前患者体检记录
    const getCurPatientRecords = computed(() => curPatientRecords.value || [])
    
    // 处理API错误
    const handleApiError = (error, defaultMessage) => {
        console.error(defaultMessage, error);
        
        let errorMessage = defaultMessage;
        if (typeof error === 'object' && error !== null) {
            if (error.message) {
                errorMessage = error.message;
            } else if (error.msg) {
                errorMessage = error.msg;
            }
        }
        
        // 通知用户
        uni.showToast({
            title: errorMessage,
            icon: 'none'
        });
        
        return new Error(errorMessage);
    };
    
    // 设置当前患者ID
    const setCurPatientId = async (patientId) => {
        try {
            if (!patientId) {
                throw new Error('患者ID不能为空');
            }
            
            console.log('设置当前患者ID:', patientId, typeof patientId);
            
            // 确保ID为字符串类型
            const stringId = String(patientId);
            
            // 更新绑定关系
            bindingStore.setCurBindingId(patientId);
            
            // 在更新患者列表前，先打印日志帮助排查
            console.log('查找患者ID前，当前患者列表状态:');
            logPatientList();
            
            // 改进的查找逻辑：支持数字和字符串类型
            const patient = patientList.value.find(p => 
                p.id == patientId || String(p.id) === stringId
            );
            
            console.log('匹配患者结果:', patient ? '找到' : '未找到', patient?.id);
            
            if (patient) {
                // 找到患者信息，直接设置
                curPatient.value = patient;
                
                try {
                    // 获取该患者的健康数据
                    await fetchCurPatientHealthData(patientId);
                    // 获取该患者的体检记录
                    await fetchCurPatientRecords(patientId);
                } catch (innerError) {
                    console.error('获取患者相关数据失败:', innerError);
                }
                
                return patient;
            } else {
                // 未找到患者信息，尝试重新获取患者列表
                console.warn('未在本地找到该患者信息，尝试重新获取患者列表');
                console.log('当前患者列表:', JSON.stringify(patientList.value));
                
                const patients = await fetchPatientList();
                
                // 改进的查找逻辑：使用返回值直接查找
                const refetchedPatient = patients.find(p => 
                    p.id == patientId || String(p.id) === stringId
                );
                
                console.log('重新获取后匹配结果:', refetchedPatient ? '找到' : '未找到', refetchedPatient?.id);
                
                if (refetchedPatient) {
                    curPatient.value = refetchedPatient;
                    
                    try {
                        // 获取该患者的健康数据和体检记录
                        await fetchCurPatientHealthData(patientId);
                        await fetchCurPatientRecords(patientId);
                    } catch (innerError) {
                        console.error('获取患者相关数据失败:', innerError);
                    }
                    
                    return refetchedPatient;
                } else {
                    // 创建一个临时的患者对象以避免UI错误
                    console.log(`未能找到ID为${patientId}的患者。尝试直接获取health data`);
                    
                    // 直接使用ID创建临时患者并获取健康数据
                    const tempPatient = {
                        id: stringId,
                        name: '未知患者',
                        sex: 'unknown',
                        age: '--',
                        phone: '--',
                        bloodType: '--',
                        healthStatus: 'normal'
                    };
                    
                    curPatient.value = tempPatient;
                    
                    // 尝试获取健康数据，即使没有找到患者
                    try {
                        const healthDataResult = await healthData.fetchRealtimeData(patientId);
                        if (healthDataResult && healthDataResult.id) {
                            // 如果健康数据中包含患者信息，更新临时患者
                            if (healthDataResult.name) tempPatient.name = healthDataResult.name;
                            if (healthDataResult.sex) tempPatient.sex = healthDataResult.sex;
                            if (healthDataResult.age) tempPatient.age = healthDataResult.age;
                            if (healthDataResult.healthStatus) tempPatient.healthStatus = healthDataResult.healthStatus;
                            
                            console.log('从健康数据更新患者信息:', tempPatient);
                        }
                    } catch (healthError) {
                        console.error('获取健康数据失败:', healthError);
                    }
                    
                    await fetchCurPatientHealthData(patientId);
                    
                    console.warn(`未能找到ID为${patientId}的患者信息，已创建临时患者对象`);
                    return tempPatient;
                }
            }
        } catch (error) {
            handleApiError(error, '设置当前患者失败');
            return null;
        }
    };
    
    // 更新患者列表
    const setPatientList = (list) => {
        if (!list || !Array.isArray(list)) {
            console.warn('设置患者列表失败：提供的列表无效');
            return;
        }
        patientList.value = list;
    };
    
    // 获取患者列表
    const fetchPatientList = async () => {
        // 防止重复加载
        if (loading.value.patientList) return patientList.value;
        
        loading.value.patientList = true;
        try {
            // 从绑定关系获取患者列表
            await bindingStore.fetchBindingList();
            const bindings = bindingStore.getBindingList;
            
            // 打印绑定数据的详细信息，帮助调试
            console.log('绑定数据详情:', JSON.stringify(bindings));
            
            if (!bindings) {
                console.warn('绑定列表数据为空');
                patientList.value = [];
                return [];
            }
            
            // 如果bindings是对象而非数组，尝试获取它的数组属性
            let bindingsArray = bindings;
            if (!Array.isArray(bindings) && typeof bindings === 'object') {
                // 尝试找到对象中的数组属性
                for (const key in bindings) {
                    if (Array.isArray(bindings[key])) {
                        bindingsArray = bindings[key];
                        console.log('从对象中提取绑定数组:', key);
                        break;
                    }
                }
            }
            
            if (!Array.isArray(bindingsArray)) {
                console.warn('绑定列表不是数组类型', typeof bindingsArray);
                patientList.value = [];
                return [];
            }
            
            // 规范化ID类型 - 确保ID为字符串类型
            const normalizedPatients = bindingsArray.map(binding => ({
                id: String(binding.id || ''),
                name: binding.name || '未命名',
                sex: binding.sex || 'unknown',
                age: binding.age || '--',
                phone: binding.phone || '--',
                bloodType: binding.bloodType || '--',
                healthStatus: binding.healthStatus || 'normal',
            }));
            
            console.log('规范化后的患者列表:', normalizedPatients);
            patientList.value = normalizedPatients;
            
            console.log('成功获取患者列表:', patientList.value.length, '名患者');
            logPatientList();
            
            // 如果有患者列表但没有当前选中的患者，自动选择第一个
            if (patientList.value.length > 0 && !curPatient.value) {
                await setCurPatientId(patientList.value[0].id);
            }
            
            return patientList.value;
        } catch (error) {
            console.error('获取患者列表错误:', error);
            patientList.value = [];
            handleApiError(error, '获取患者列表失败');
            return [];
        } finally {
            loading.value.patientList = false;
        }
    };
    
    // 获取当前患者的健康数据
    const fetchCurPatientHealthData = async (patientId) => {
        if (loading.value.healthData) return curPatientHealthData.value;
        
        loading.value.healthData = true;
        try {
            // 添加参数验证
            if (!patientId) {
                throw new Error('患者ID不能为空');
            }
            
            // 初始化默认健康数据，用于任何情况下都能有值显示
            curPatientHealthData.value = {
                collectTime: new Date().toISOString(),
                heartRate: '--',
                bloodOxygen: '--',
                bloodPressureHigh: '--',
                bloodPressureLow: '--',
                bodyTemperature: '--',
                healthStatus: 'normal'
            };
            
            try {
                // 尝试使用 healthData store 获取实时健康数据
                const healthDataResult = await healthData.fetchRealtimeData(patientId);
                
                // 健康数据有效性检查
                if (healthDataResult && Object.keys(healthDataResult).length > 0) {
                    // 更新健康数据
                    curPatientHealthData.value = {
                        ...curPatientHealthData.value,  // 保留默认值
                        ...healthDataResult,  // 使用获取到的值覆盖默认值
                        healthStatus: healthDataResult.healthStatus || 'normal'
                    };
                    
                    try {
                        // 并行获取历史数据
                        const results = await Promise.all([
                            healthData.fetchHeartRateDetail(patientId, 'day').catch(() => []),
                            healthData.fetchBloodPressureDetail(patientId, 'day').catch(() => []),
                            healthData.fetchBloodOxygenDetail(patientId, 'day').catch(() => []),
                            healthData.fetchSleepDetail(patientId, 'day').catch(() => []),
                            healthData.fetchActivityDetail(patientId, 'day').catch(() => [])
                        ]);
                        
                        const [
                            heartRateHistory,
                            bloodPressureHistory,
                            bloodOxygenHistory,
                            sleepData,
                            activityData
                        ] = results;
                        
                        // 补充历史数据
                        curPatientHealthData.value = {
                            ...curPatientHealthData.value,
                            heartRateHistory,
                            bloodPressureHistory,
                            bloodOxygenHistory,
                            sleepData,
                            activityData
                        };
                    } catch (historyError) {
                        console.warn('获取健康历史数据失败，使用默认空数据:', historyError);
                        // 提供默认的历史数据结构
                        curPatientHealthData.value = {
                            ...curPatientHealthData.value,
                            heartRateHistory: [],
                            bloodPressureHistory: [],
                            bloodOxygenHistory: [],
                            sleepData: [],
                            activityData: []
                        };
                    }
                    
                    // 更新患者列表中的健康状态
                    updatePatientHealthStatus(patientId, curPatientHealthData.value.healthStatus);
                }
            } catch (error) {
                console.warn('获取健康实时数据失败，使用默认数据:', error);
                // 已经有默认值，不需要额外处理
            }
            
            return curPatientHealthData.value;
        } catch (error) {
            console.error('获取患者健康数据失败:', error);
            // 静默处理错误，确保UI始终有数据显示
            if (!curPatientHealthData.value) {
                curPatientHealthData.value = getDefaultHealthData();
            }
            return curPatientHealthData.value;
        } finally {
            loading.value.healthData = false;
        }
    };
    
    // 获取默认健康数据结构
    const getDefaultHealthData = () => {
        return {
            collectTime: new Date().toISOString(),
            heartRate: '--',
            bloodOxygen: '--',
            bloodPressureHigh: '--',
            bloodPressureLow: '--',
            bodyTemperature: '--',
            healthStatus: 'normal',
            heartRateHistory: [],
            bloodPressureHistory: [],
            bloodOxygenHistory: [],
            sleepData: [],
            activityData: []
        };
    };
    
    // 更新患者在列表中的健康状态
    const updatePatientHealthStatus = (patientId, status) => {
        if (!patientId || !patientList.value || !Array.isArray(patientList.value)) return;
        
        // 支持字符串和数字类型的ID比较
        const index = patientList.value.findIndex(p => 
            p.id === patientId || p.id === String(patientId) || String(p.id) === String(patientId)
        );
        
        if (index !== -1) {
            patientList.value[index].healthStatus = status;
        }
    };
    
    // 获取当前患者的体检记录
    const fetchCurPatientRecords = async (patientId) => {
        if (loading.value.records) return curPatientRecords.value;
        
        loading.value.records = true;
        try {
            // 添加参数验证
            if (!patientId) {
                throw new Error('患者ID不能为空');
            }
            
            try {
                const res = await get(`/record/${patientId}/medicalRecord`, 'api/v1');
                if (res && res?.code === 200) {
                    curPatientRecords.value = res.data || [];
                } else {
                    curPatientRecords.value = [];
                    if (res?.msg) {
                        console.warn('获取体检记录返回错误:', res.msg);
                    }
                }
            } catch (error) {
                console.error('获取患者体检记录失败:', error);
                curPatientRecords.value = [];
            }
            
            return curPatientRecords.value;
        } catch (error) {
            console.warn('获取患者体检记录参数验证失败:', error);
            curPatientRecords.value = [];
            return [];
        } finally {
            loading.value.records = false;
        }
    };
    
    // 添加新患者
    const addPatient = async (patientData) => {
        try {
            if (!patientData || !patientData.phone) {
                throw new Error('患者信息不完整');
            }
            
            // 通过绑定关系添加患者
            await bindingStore.addBinding(patientData);
            // 重新获取患者列表
            await fetchPatientList();
            return true;
        } catch (error) {
            handleApiError(error, '添加患者失败');
            return false;
        }
    };
    
    // 删除患者
    const deletePatient = async (patientId) => {
        try {
            if (!patientId) {
                throw new Error('患者ID不能为空');
            }
            
            await bindingStore.deleteBinding(patientId);
            // 重新获取患者列表
            await fetchPatientList();
            // 如果删除的是当前患者，重置当前患者
            if (curPatient.value?.id === patientId) {
                curPatient.value = null;
                curPatientHealthData.value = null;
                curPatientRecords.value = [];
            }
            return true;
        } catch (error) {
            handleApiError(error, '删除患者失败');
            return false;
        }
    };
    
    // 更新患者信息
    const updatePatient = async (patientId, updateData) => {
        try {
            if (!patientId) {
                throw new Error('患者ID不能为空');
            }
            
            const res = await post(`/patients/${patientId}`, updateData, 'api/v1');
            if (res?.code === 200) {
                // 更新本地数据
                const index = patientList.value.findIndex(p => p.id === patientId);
                if (index !== -1) {
                    patientList.value[index] = { ...patientList.value[index], ...updateData };
                    // 如果更新的是当前患者，同步更新当前患者信息
                    if (curPatient.value?.id === patientId) {
                        curPatient.value = { ...curPatient.value, ...updateData };
                    }
                    return true;
                }
            } else {
                throw new Error(res?.msg || '更新患者信息失败');
            }
        } catch (error) {
            handleApiError(error, '更新患者信息失败');
            return false;
        }
    };
    
    // 清空当前患者数据
    const clearCurrentPatient = () => {
        curPatient.value = null;
        curPatientHealthData.value = null;
        curPatientRecords.value = [];
    };
    
    // 监听绑定关系变化
    watch(() => bindingStore.getBindingList, async (newList) => {
        if (!newList) return;
        
        let bindingsArray = newList;
        // 处理可能的对象包装情况
        if (!Array.isArray(newList) && typeof newList === 'object') {
            for (const key in newList) {
                if (Array.isArray(newList[key])) {
                    bindingsArray = newList[key];
                    break;
                }
            }
        }
        
        if (Array.isArray(bindingsArray) && bindingsArray.length > 0) {
            // 只有当绑定列表确实发生变化时才刷新患者列表
            const currentPatientId = curPatient.value?.id;
            const newPatientList = bindingsArray.map(binding => ({
                id: binding.id || '',
                name: binding.name || '未命名',
                sex: binding.sex || 'unknown',
                age: binding.age || '--',
                phone: binding.phone || '--',
                bloodType: binding.bloodType || '--',
                healthStatus: binding.healthStatus || 'normal'
            }));
            
            // 检查是否是初始化加载还是后续更新
            const isInitialLoad = !patientList.value.length;
            
            // 更新患者列表
            patientList.value = newPatientList;
            
            // 如果是初始化加载或当前患者不在新列表中，则自动选择第一个
            if (isInitialLoad || !currentPatientId || !newPatientList.some(p => p.id === currentPatientId)) {
                if (newPatientList.length > 0) {
                    await setCurPatientId(newPatientList[0].id);
                }
            }
        }
    });
    
    // 监听当前绑定ID变化
    watch(() => bindingStore.getCurBindingId, async (newId) => {
        if (newId) {
            await setCurPatientId(newId);
        }
    });
    
    // 工具方法 - 用于调试
    const logPatientList = () => {
        console.log('当前患者列表详情:');
        if (!patientList.value || !patientList.value.length) {
            console.log('患者列表为空');
            return;
        }

        patientList.value.forEach((p, index) => {
            console.log(`患者 ${index + 1}: ID=${p.id}(${typeof p.id}), 姓名=${p.name}`);
        });
    };

    return {
        // 状态
        patientList,
        curPatient,
        curPatientHealthData,
        curPatientRecords,
        loading,
        
        // 计算属性
        getPatientList,
        getCurPatient,
        getCurPatientHealthData,
        getCurPatientRecords,
        
        // 方法
        setCurPatientId,
        setPatientList,
        fetchPatientList,
        fetchCurPatientHealthData,
        fetchCurPatientRecords,
        addPatient,
        deletePatient,
        updatePatient,
        clearCurrentPatient,
        logPatientList
    };
});
